home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / Peter Lewis (TCPExample) / PNL Libraries / TCPTypes.p < prev    next >
Encoding:
Text File  |  1995-10-22  |  14.4 KB  |  637 lines  |  [TEXT/CWIE]
  1. unit TCPTypes;
  2.  
  3. { TCPTypes © Peter Lewis, Oct 1991 }
  4. { This source is Freeware }
  5.  
  6. interface
  7.  
  8.     uses
  9.         Types, OSUtils;
  10.  
  11. { MacTCP return Codes in the range -23000 through -23049 }
  12.     const
  13.         ipBadLapErr = -23000;                    { bad network configuration }
  14.         ipBadCnfgErr = -23001;                { bad IP configuration error }
  15.         ipNoCnfgErr = -23002;                    { missing IP or LAP configuration error }
  16.         ipLoadErr = -23003;                    { error in MacTCP load }
  17.         ipBadAddrErr = -23004;                    { error in getting address }
  18.         connectionClosingErr = -23005;            { connection is closing }
  19.         invalidLengthErr = -23006;
  20.         connectionExistsErr = -23007;            { request conflicts with existing connection }
  21.         connectionDoesntExistErr = -23008;        { connection does not exist }
  22.         insufficientResourcesErr = -23009;        { insufficient resources to perform request }
  23.         invalidStreamPtrErr = -23010;
  24.         streamAlreadyOpenErr = -23011;
  25.         connectionTerminatedErr = -23012;
  26.         invalidBufPtrErr = -23013;
  27.         invalidRDSErr = -23014;
  28.         invalidWDSErr = -23014;
  29.         openFailedErr = -23015;
  30.         commandTimeoutErr = -23016;
  31.         duplicateSocketErr = -23017;
  32.  
  33. { Error codes from internal IP functions }
  34.         ipDontFragErr = -23032;                { Packet too large to send w/o fragmenting }
  35.         ipDestDeadErr = -23033;                { destination not responding }
  36.         icmpEchoTimeoutErr = -23035;        { ICMP echo timed-out }
  37.         ipNoFragMemErr = -23036;            { no memory to send fragmented pkt }
  38.         ipRouteErr = -23037;                    { can't route packet off-net }
  39.  
  40.         nameSyntaxErr = -23041;
  41.         cacheFaultErr = -23042;
  42.         noResultProcErr = -23043;
  43.         noNameServerErr = -23044;
  44.         authNameErrErr = -23045;
  45.         noAnsErr = -23046;
  46.         dnrErr = -23047;
  47.         outOfMemoryErr = -23048;
  48.  
  49. { connectionState }
  50.     const
  51.         CState_Closed = 0;
  52.         CState_Listening = 2;
  53.         CState_Opening1 = 4;
  54.         CState_Opening2 = 6;
  55.         CState_Established = 8;
  56.         CState_Closing1 = 10;
  57.         CState_Closing2 = 12;
  58.         CState_Closing3 = 16;
  59.         CState_Closing4 = 18;
  60.         CState_Closing5 = 20;
  61.         CState_PleaseClose = 14;
  62.  
  63.     type
  64.         AddrClasses = integer;
  65.     const
  66.         AC_A = 1;
  67.         AC_NS = 2;
  68.         AC_CNAME = 5;
  69.         AC_HINFO = 13;
  70.         AC_MX = 15;
  71.  
  72.     const
  73.         CTRUE = $FF;
  74.         CFALSE = $00;
  75.  
  76.     type
  77.         C_BOOLEAN = signedByte;
  78.         CSTRING = ptr;
  79.         CStr30 = packed array[0..29] of char;
  80.         CStr255 = packed array[0..255] of char;
  81.         ipAddr = longint;
  82.         ipPort = integer;
  83.         StreamPtr = ptr;
  84.  
  85.     type
  86.         wdsType = record            { Write block for TCP driver. }
  87.                 size: UInt16;                { Number of bytes. }
  88.                 buffer: Ptr;                { Pointer to bytes. }
  89.                 term: UInt16;                { Zero for end of blocks. }
  90.             end;
  91.         wdsPtr = ^wdsType;
  92.         wdsEntry = record
  93.                 size: UInt16;                { Number of bytes. }
  94.                 buffer: Ptr;                { Pointer to bytes. }
  95.             end;
  96.  
  97.         hostInfo = record
  98.                 rtnCode: longint;
  99.                 rtnHostName: Str255;
  100.                 addrs: array[1..4] of ipAddr;
  101.             end;
  102.         hostInfoPtr = ^hostInfo;
  103.  
  104.     type
  105.         HInfoRec = record
  106.                 cpuType: CStr30;
  107.                 osType: CStr30;
  108.             end;
  109.  
  110.     type
  111.         MXRec = record
  112.                 preference: integer; { unsigned! }
  113.                 exchange: CStr255;
  114.             end;
  115.  
  116.     type
  117.         hmxInfoRec = record
  118.                 rtcCode: integer;
  119.                 cname: CStr255;
  120.                 case integer of
  121.                     1: (
  122.                             addr: array[1..4] of ipAddr;
  123.                     );
  124.                     2: (
  125.                             hinfo: HInfoRec;
  126.                     );
  127.                     3: (
  128.                             mx: MXRec;
  129.                     );
  130.             end;
  131.         hmxInfoRecPtr = ^hmxInfoRec;
  132.  
  133.     type
  134.         cacheEntryRecord = record
  135.                 cname: CSTRING;
  136.                 typ: integer;
  137.                 class: integer;
  138.                 ttl: longint;
  139.                 case integer of
  140.                     1: (
  141.                             name: CSTRING;
  142.                     );
  143.                     2: (
  144.                             addr: ipAddr;
  145.                     );
  146.             end;
  147.         cacheEntryRecordPtr = ^cacheEntryRecord;
  148.  
  149.     const { csCodes for the TCP driver: }
  150.         TCPcsGetMyIP = 15;
  151.         TCPcsEchoICMP = 17;
  152.         TCPcsLAPStats = 19;
  153.         TCPcsCreate = 30;
  154.         TCPcsPassiveOpen = 31;
  155.         TCPcsActiveOpen = 32;
  156. {    TCPcsActOpenWithData = 33;}
  157.         TCPcsSend = 34;
  158.         TCPcsNoCopyRcv = 35;
  159.         TCPcsRcvBfrReturn = 36;
  160.         TCPcsRcv = 37;
  161.         TCPcsClose = 38;
  162.         TCPcsAbort = 39;
  163.         TCPcsStatus = 40;
  164.         TCPcsExtendedStat = 41;
  165.         TCPcsRelease = 42;
  166.         TCPcsGlobalInfo = 43;
  167.  
  168.         UDPcsCreate = 20;
  169.         UDPcsRead = 21;
  170.         UDPcsBfrReturn = 22;
  171.         UDPcsWrite = 23;
  172.         UDPcsRelease = 24;
  173.         UDPcsMaxMTUSize = 25;
  174.         UDPcsStatus = 26;
  175.         UDPcsMultiCreate = 27;
  176.         UDPcsMultiSend = 28;
  177.         UDPcsMultiRead = 29;
  178.  
  179.     type
  180.         TCPEventCode = integer;
  181.     const
  182.         TEC_Closing = 1;
  183.         TEC_ULPTimeout = 2;
  184.         TEC_Terminate = 3;
  185.         TEC_DataArrival = 4;
  186.         TEC_Urgent = 5;
  187.         TEC_ICMPReceived = 6;
  188.         TEC_last = 32767;
  189.  
  190.     type
  191.         UDPEventCode = integer;
  192.     const
  193.         UDPDataArrival = 1;
  194.         UDPICMPReceived = 2;
  195.         lastUDPEvent = 32767;
  196.  
  197.     type
  198.         TCPTerminateReason = integer;
  199.     const {TCPTerminateReasons: }
  200.         TTR_RemoteAbort = 2;
  201.         TTR_NetworkFailure = 3;
  202.         TTR_SecPrecMismatch = 4;
  203.         TTR_ULPTimeoutTerminate = 5;
  204.         TTR_ULPAbort = 6;
  205.         TTR_ULPClose = 7;
  206.         TTR_ServiceError = 8;
  207.         TTR_last = 32767;
  208.  
  209.     type
  210.         ICMPMsgType = integer;
  211.     const
  212.         ICMP_NetUnreach = 0;
  213.         ICMP_HostUnreach = 1;
  214.         ICMP_ProtocolUnreach = 2;
  215.         ICMP_PortUnreach = 3;
  216.         ICMP_FragReqd = 4;
  217.         ICMP_SourceRouteFailed = 5;
  218.         ICMP_TimeExceeded = 6;
  219.         ICMP_ParmProblem = 7;
  220.         ICMP_MissingOption = 8;
  221.  
  222.     type
  223.         TCPNotifyProc = procPtr;
  224. { procedure TCPNotifyProc(tcpStream:StreamPtr; event:TCPEventCode; userDataPtr:ptr; }
  225. {                                   terminReason:TCPTerminateReason; icmpMsg:ICMPReportPtr); }
  226.  
  227.     type
  228.         TCPIOCompletionProc = procPtr;
  229. { C procedure TCPIOCompletionProc(iopb:TCPControlBlockPtr); - WHY IS THIS A C PROC???? }
  230.  
  231.     type
  232.         UDPNotifyProc = procPtr;
  233. { procedure UDPProc(udpStream:StreamPtr ; eventCode:integer;userDataPtr:ptr; icmpMsg:ICMPReportPtr) }
  234.  
  235.     type
  236.         UDPIOCompletionProc = procPtr;
  237. { C procedure UDPIOCompletionProc(iopb:UDPiopb Ptr) }
  238.  
  239.     type
  240.         ICMPEchoNotifyProc = ProcPtr;
  241. { C procedure ICMPEchoNotifyProc(iopb:IPControlBlockPtr) }
  242. { WARNING: Ignore the docs, its a C proceudre no matter what they say }
  243.  
  244.     type
  245.         ICMPReport = record
  246.                 stream: StreamPtr;
  247.                 localHost: ipAddr;
  248.                 localPort: ipPort;
  249.                 remoteHost: ipAddr;
  250.                 remotePort: ipPort;
  251.                 reportType: ICMPMsgType;
  252.                 optionalAddlInfo: integer;
  253.                 optionalAddlInfoPtr: ptr;
  254.             end;
  255.  
  256.     const
  257.         NBP_TABLE_SIZE = 20;            { number of NBP table entries }
  258.         NBP_MAX_NAME_SIZE = 16 + 10 + 2;
  259.         ARP_TABLE_SIZE = 20;            { number of ARP table entries }
  260.  
  261.     type
  262.         nbpEntry = record
  263.                 ip_address: ipAddr;                { IP address }
  264.                 at_address: longint;                { matching AppleTalk address }
  265.                 gateway: Boolean;                { TRUE if entry for a gateway }
  266.                 valid: Boolean;                    { TRUE if LAP address is valid }
  267.                 probing: Boolean;                { TRUE if NBP lookup pending }
  268.                 age: integer;                    { ticks since cache entry verified }
  269.                 access: integer;                    { ticks since last access }
  270.                 filler: packed array[1..116] of byte;            { for internal use only !!! }
  271.             end;
  272.         EnetAddr = record
  273.                 en_hi: integer;
  274.                 en_lo: longint;
  275.             end;
  276.         arpEntry = record
  277.                 age: integer;            { cache aging field }
  278.                 protocol: integer;        { Protocol type }
  279.                 ip_address: ipAddr;        { IP address }
  280.                 en_address: EnetAddr;        { matching Ethernet address }
  281.             end;
  282.         AddrXlation = record
  283.                 case integer of
  284.                     0: (
  285.                             arp_table: ^arpEntry
  286.                     );
  287.                     1: (
  288.                             nbp_entry: ^nbpEntry
  289.                     )
  290.             end;
  291.         LAPStats = record
  292.                 ifType: integer;
  293.                 ifString: CSTRING;
  294.                 ifMaxMTU: integer;
  295.                 ifSpeed: longint;
  296.                 ifPhyAddrLength: integer;
  297.                 ifPhysicalAddress: CSTRING;
  298.                 addr: AddrXlation;
  299.                 slotNumber: integer;
  300.             end;
  301.         IPEchoPB = record
  302.                 dest: ipAddr;                { echo to IP address }
  303.                 data: wdsEntry;
  304.                 timeout: integer;
  305.                 options: Ptr;
  306.                 optLength: integer;
  307.                 icmpCompletion: ICMPEchoNotifyProc;
  308.                 userDataPtr: ptr;
  309.             end;
  310.         LAPStatsPB = record
  311.                 lapStatsPtr: ^LAPStats;
  312.             end;
  313.         ICMPEchoInfo = record
  314.                 params: array[1..11] of integer;
  315.                 echoRequestOut: longint;    { time in ticks of when the echo request went out }
  316.                 echoReplyIn: longint;        { time in ticks of when the reply was received }
  317.                 data: wdsEntry;        { data received in responce }
  318.                 options: ptr;
  319.                 userDataPtr: ptr;
  320.             end;
  321.         IPGetMyIPPB = record
  322.                 ourAddress: ipAddr;            { our IP address }
  323.                 ourNetMask: ipAddr;            { our IP net mask }
  324.             end;
  325.  
  326.         IPControlBlock = record
  327.                 qLink: QElemPtr;
  328.                 qType: INTEGER;
  329.                 ioTrap: INTEGER;
  330.                 ioCmdAddr: Ptr;
  331.                 ioCompletion: TCPIOCompletionProc; {completion routine, or NIL if none}
  332.                 ioResult: OSErr; {result code}
  333.                 ioNamePtr: StringPtr;
  334.                 ioVRefNum: INTEGER;
  335.                 ioCRefNum: INTEGER; {device refnum}
  336.                 case csCode : integer of
  337.                     TCPcsGetMyIP: (
  338.                             getmyip: IPGetMyIPPB;
  339.                     );
  340.                     TCPcsEchoICMP: (
  341.                             echo: IPEchoPB
  342.                     );
  343.                     9999: (
  344.                             echoinfo: ICMPEchoInfo
  345.                     );
  346.                     TCPcsLAPStats: (
  347.                             lapstat: LAPStatsPB
  348.                     );
  349.             end;
  350.         IPControlBlockPtr = ^IPControlBlock;
  351.  
  352.     type
  353.         UDPCreatePB = record { for create and release calls }
  354.                 rcvBuff: Ptr;
  355.                 rcvBuffLen: longint;
  356.                 notifyProc: UDPNotifyProc;
  357.                 localport: ipPort;
  358.                 userDataPtr: ptr;
  359.                 endingPort: ipPort;
  360.             end;
  361.  
  362.     type
  363.         UDPSendPB = record
  364.                 reserved: integer;
  365.                 remoteIP: ipAddr;
  366.                 remotePort: ipPort;
  367.                 wds: wdsPtr;
  368.                 checkSum: signedByte;
  369.                 sendLength: integer;
  370.                 userDataPtr: ptr;
  371.                 localPort: ipPort;
  372.             end;
  373.  
  374.     type
  375.         UDPReceivePB = record
  376.                 timeOut: integer;
  377.                 remoteIP: ipAddr;
  378.                 remotePort: ipPort;
  379.                 rcvBuff: ptr;
  380.                 rcvBuffLen: integer;
  381.                 secondTimeStamp: integer;
  382.                 userDataPtr: ptr;
  383.                 destHost: ipAddr;
  384.                 destPort: ipPort;
  385.             end;
  386.  
  387.     type
  388.         UDPMTUPB = record
  389.                 mtuSize: integer;
  390.                 remoteIP: ipAddr;
  391.                 userDataPtr: ptr;
  392.             end;
  393.  
  394.     type
  395.         UDPControlBlock = record
  396.                 qLink: QElemPtr;
  397.                 qType: INTEGER;
  398.                 ioTrap: INTEGER;
  399.                 ioCmdAddr: Ptr;
  400.                 ioCompletion: UDPIOCompletionProc;
  401.                 ioResult: OSErr;
  402.                 ioNamePtr: stringPtr;
  403.                 ioVRefNum: integer;
  404.                 ioCRefNum: integer;
  405.                 csCode: integer;
  406.                 udpStream: streamPtr;
  407.                 case integer of
  408.                     UDPcsCreate, UDPcsMultiCreate, UDPcsRelease: (
  409.                             create: UDPCreatePB
  410.                     );
  411.                     UDPcsWrite, UDPcsMultiSend: (
  412.                             send: UDPSendPB
  413.                     );
  414.                     UDPcsRead, UDPcsMultiRead: (
  415.                             receive: UDPReceivePB
  416.                     );
  417.                     UDPcsBfrReturn: (
  418.                             return: UDPReceivePB
  419.                     );
  420.                     UDPcsMaxMTUSize: (
  421.                             mtu: UDPMTUPB
  422.                     );
  423.             end;
  424.         UDPControlBlockPtr = ^UDPControlBlock;
  425.  
  426.     const { Validity Flags }
  427.         timeOutValue = $80;
  428.         timeOutAction = $40;
  429.         typeOfService = $20;
  430.         precedence = $10;
  431.  
  432.     const { TOSFlags }
  433.         lowDelay = $01;
  434.         throughPut = $02;
  435.         reliability = $04;
  436.  
  437.     type
  438.         TCPCreatePB = packed record
  439.                 rcvBuff: ptr;
  440.                 rcvBuffLen: longint;
  441.                 notifyProc: TCPNotifyProc;
  442.                 userDataPtr: ptr;
  443.             end;
  444.  
  445.         TCPOpenPB = packed record
  446.                 ulpTimeoutValue: byte;
  447.                 ulpTimeoutAction: signedByte;
  448.                 validityFlags: byte;
  449.                 commandTimeoutValue: byte;
  450.                 remoteHost: ipAddr;
  451.                 remotePort: ipPort;
  452.                 localHost: ipAddr;
  453.                 localPort: ipPort;
  454.                 tosFlags: byte;
  455.                 precedence: byte;
  456.                 dontFrag: C_BOOLEAN;
  457.                 timeToLive: byte;
  458.                 security: byte;
  459.                 optionCnt: byte;
  460.                 options: array[0..39] of byte;
  461.                 userDataPtr: ptr;
  462.             end;
  463.  
  464.         TCPSendPB = packed record
  465.                 ulpTimeoutValue: byte;
  466.                 ulpTimeoutAction: signedByte;
  467.                 validityFlags: byte;
  468.                 pushFlag: byte;
  469.                 urgentFlag: C_BOOLEAN;
  470.                 wds: wdsptr;
  471.                 sendFree: longint;
  472.                 sendLength: integer;
  473.                 userDataPtr: ptr;
  474.             end;
  475.  
  476.         TCPReceivePB = packed record
  477.                 commandTimeoutValue: byte;
  478.                 filler: byte;
  479.                 markFlag: C_BOOLEAN;
  480.                 urgentFlag: C_BOOLEAN;
  481.                 rcvBuff: ptr;
  482.                 rcvBuffLength: integer;
  483.                 rdsPtr: ptr;
  484.                 rdsLength: integer;
  485.                 secondTimeStamp: integer;
  486.                 userDataPtr: ptr;
  487.             end;
  488.  
  489.         TCPClosePB = packed record
  490.                 ulpTimeoutValue: byte;
  491.                 ulpTimeoutAction: signedByte;
  492.                 validityFlags: byte;
  493.                 userDataPtrX: ptr;   { Thats mad!  Its not on a word boundary! Parhaps a documentation bug??? }
  494.             end;
  495.  
  496.         HistoBucket = packed record
  497.                 value: integer;
  498.                 counter: longint;
  499.             end;
  500.  
  501.     const
  502.         NumOfHistoBuckets = 7;
  503.  
  504.     type
  505.         TCPConnectionStats = packed record
  506.                 dataPktsRcvd: longint;
  507.                 dataPktsSent: longint;
  508.                 dataPktsResent: longint;
  509.                 bytesRcvd: longint;
  510.                 bytesRcvdDup: longint;
  511.                 bytesRcvdPastWindow: longint;
  512.                 bytesSent: longint;
  513.                 bytesResent: longint;
  514.                 numHistoBuckets: integer;
  515.                 sentSizeHisto: array[1..NumOfHistoBuckets] of HistoBucket;
  516.                 lastRTT: integer;
  517.                 tmrRTT: integer;
  518.                 rttVariance: integer;
  519.                 tmrRTO: integer;
  520.                 sendTries: byte;
  521.                 sourceQuenchRcvd: byte;
  522.             end;
  523.         TCPConnectionStatsPtr = ^TCPConnectionStats;
  524.  
  525.         TCPStatusPB = packed record
  526.                 ulpTimeoutValue: byte;
  527.                 ulpTimeoutAction: signedByte;
  528.                 unused: longint;
  529.                 remoteHost: ipAddr;
  530.                 remotePort: ipPort;
  531.                 localHost: ipAddr;
  532.                 localPort: ipPort;
  533.                 tosFlags: byte;
  534.                 precedence: byte;
  535.                 connectionState: byte;
  536.                 filler: byte;
  537.                 sendWindow: integer;
  538.                 rcvWindow: integer;
  539.                 amtUnackedData: integer;
  540.                 amtUnreadData: integer;
  541.                 securityLevelPtr: ptr;
  542.                 sendUnacked: longint;
  543.                 sendNext: longint;
  544.                 congestionWindow: longint;
  545.                 rcvNext: longint;
  546.                 srtt: longint;
  547.                 lastRTT: longint;
  548.                 sendMaxSegSize: longint;
  549.                 connStatPtr: TCPConnectionStatsPtr;
  550.                 userDataPtr: ptr;
  551.             end;
  552.  
  553.         TCPAbortPB = packed record
  554.                 userDataPtr: ptr;
  555.             end;
  556.  
  557.         TCPParam = packed record
  558.                 tcpRTOA: StringPtr;
  559.                 tcpRTOMin: longint;
  560.                 tcpRTOMax: longint;
  561.                 tcpMaxSegSize: longint;
  562.                 tcpMaxConn: longint;
  563.                 tcpMaxWindow: longint;
  564.             end;
  565.         TCPParamPtr = ^TCPParam;
  566.  
  567.         TCPStats = packed record
  568.                 tcpConnAttempts: longint;
  569.                 tcpConnOpened: longint;
  570.                 tcpConnAccepted: longint;
  571.                 tcpConnClosed: longint;
  572.                 tcpConnAborted: longint;
  573.                 tcpOctetsIn: longint;
  574.                 tcpOctetsOut: longint;
  575.                 tcpOctetsInDup: longint;
  576.                 tcpOctetsRetrans: longint;
  577.                 tcpInputPackets: longint;
  578.                 tcpOutputPkts: longint;
  579.                 tcpDupPkts: longint;
  580.                 tcpRetransPkts: longint;
  581.             end;
  582.         TCPStatsPtr = ^TCPStats;
  583.  
  584.         StreamPtrArray = array[1..1000] of StreamPtr;
  585.         StreamPtrArrayPtr = ^StreamPtrArray;
  586.  
  587.         TCPGlobalInfoPB = packed record
  588.                 tcpParamp: TCPParamPtr;
  589.                 tcpStatsp: TCPStatsPtr;
  590.                 tcpCDBTable: StreamPtrArrayPtr;
  591.                 userDataPtr: ptr;
  592.                 maxTCPConnections: integer;
  593.             end;
  594.  
  595.         TCPControlBlock = record
  596.                 qLink: QElemPtr;
  597.                 qType: INTEGER;
  598.                 ioTrap: INTEGER;
  599.                 ioCmdAddr: Ptr;
  600.                 ioCompletion: TCPIOCompletionProc; {completion routine, or NIL if none}
  601.                 ioResult: OSErr; {result code}
  602.                 ioNamePtr: StringPtr;
  603.                 ioVRefNum: INTEGER;
  604.                 ioCRefNum: INTEGER; {device refnum}
  605.                 csCode: integer;
  606.                 tcpStream: StreamPtr;
  607.                 case integer of
  608.                     TCPcsCreate: (
  609.                             create: TCPCreatePB
  610.                     );
  611.                     TCPcsActiveOpen, TCPcsPassiveOpen: (
  612.                             open: TCPOpenPB;
  613.                     );
  614.                     TCPcsSend: (
  615.                             send: TCPSendPB;
  616.                     );
  617.                     TCPcsNoCopyRcv, TCPcsRcvBfrReturn, TCPcsRcv: (
  618.                             receive: TCPReceivePB;
  619.                     );
  620.                     TCPcsClose: (
  621.                             close: TCPClosePB;
  622.                     );
  623.                     TCPcsAbort: (
  624.                             abort: TCPAbortPB;
  625.                     );
  626.                     TCPcsStatus: (
  627.                             status: TCPStatusPB;
  628.                     );
  629.                     TCPcsGlobalInfo: (
  630.                             globalInfo: TCPGlobalInfoPB
  631.                     );
  632.             end;
  633.         TCPControlBlockPtr = ^TCPControlBlock;
  634.  
  635. implementation
  636.  
  637. end.